//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2022 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if compiler(>=5.5.2) && canImport(_Concurrency)

import SotoCore

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Route53RecoveryReadiness {
    // MARK: Async API Calls

    /// Creates a cell in an account.
    public func createCell(_ input: CreateCellRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateCellResponse {
        return try await self.client.execute(operation: "CreateCell", path: "/cells", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a cross-account readiness authorization. This lets you authorize another account to work with Route 53 Application Recovery Controller, for example, to check the readiness status of resources in a separate account.
    public func createCrossAccountAuthorization(_ input: CreateCrossAccountAuthorizationRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateCrossAccountAuthorizationResponse {
        return try await self.client.execute(operation: "CreateCrossAccountAuthorization", path: "/crossaccountauthorizations", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a readiness check in an account. A readiness check monitors a resource set in your application, such as a set of Amazon Aurora instances, that Application Recovery Controller is auditing recovery readiness for. The audits run once every minute on every resource that's associated with a readiness check.
    public func createReadinessCheck(_ input: CreateReadinessCheckRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateReadinessCheckResponse {
        return try await self.client.execute(operation: "CreateReadinessCheck", path: "/readinesschecks", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a recovery group in an account. A recovery group corresponds to an application and includes a list of the cells that make up the application.
    public func createRecoveryGroup(_ input: CreateRecoveryGroupRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateRecoveryGroupResponse {
        return try await self.client.execute(operation: "CreateRecoveryGroup", path: "/recoverygroups", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Creates a resource set. A resource set is a set of resources of one type that span multiple cells. You can associate a resource set with a readiness check to monitor the resources for failover readiness.
    public func createResourceSet(_ input: CreateResourceSetRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> CreateResourceSetResponse {
        return try await self.client.execute(operation: "CreateResourceSet", path: "/resourcesets", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Delete a cell. When successful, the response code is 204, with no response body.
    public func deleteCell(_ input: DeleteCellRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws {
        return try await self.client.execute(operation: "DeleteCell", path: "/cells/{CellName}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes cross account readiness authorization.
    public func deleteCrossAccountAuthorization(_ input: DeleteCrossAccountAuthorizationRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> DeleteCrossAccountAuthorizationResponse {
        return try await self.client.execute(operation: "DeleteCrossAccountAuthorization", path: "/crossaccountauthorizations/{CrossAccountAuthorization}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a readiness check.
    public func deleteReadinessCheck(_ input: DeleteReadinessCheckRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws {
        return try await self.client.execute(operation: "DeleteReadinessCheck", path: "/readinesschecks/{ReadinessCheckName}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a recovery group.
    public func deleteRecoveryGroup(_ input: DeleteRecoveryGroupRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws {
        return try await self.client.execute(operation: "DeleteRecoveryGroup", path: "/recoverygroups/{RecoveryGroupName}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Deletes a resource set.
    public func deleteResourceSet(_ input: DeleteResourceSetRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws {
        return try await self.client.execute(operation: "DeleteResourceSet", path: "/resourcesets/{ResourceSetName}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Gets recommendations about architecture designs for improving resiliency for an application, based on a recovery group.
    public func getArchitectureRecommendations(_ input: GetArchitectureRecommendationsRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetArchitectureRecommendationsResponse {
        return try await self.client.execute(operation: "GetArchitectureRecommendations", path: "/recoverygroups/{RecoveryGroupName}/architectureRecommendations", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Gets information about a cell including cell name, cell Amazon Resource Name (ARN), ARNs of nested cells for this cell, and a list of those cell ARNs with their associated recovery group ARNs.
    public func getCell(_ input: GetCellRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetCellResponse {
        return try await self.client.execute(operation: "GetCell", path: "/cells/{CellName}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Gets readiness for a cell. Aggregates the readiness of all the resources that are associated with the cell into a single value.
    public func getCellReadinessSummary(_ input: GetCellReadinessSummaryRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetCellReadinessSummaryResponse {
        return try await self.client.execute(operation: "GetCellReadinessSummary", path: "/cellreadiness/{CellName}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Gets details about a readiness check.
    public func getReadinessCheck(_ input: GetReadinessCheckRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetReadinessCheckResponse {
        return try await self.client.execute(operation: "GetReadinessCheck", path: "/readinesschecks/{ReadinessCheckName}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Gets individual readiness status for a readiness check. To see the overall readiness status for a recovery group, that considers the readiness status for all the readiness checks in the recovery group, use GetRecoveryGroupReadinessSummary.
    public func getReadinessCheckResourceStatus(_ input: GetReadinessCheckResourceStatusRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetReadinessCheckResourceStatusResponse {
        return try await self.client.execute(operation: "GetReadinessCheckResourceStatus", path: "/readinesschecks/{ReadinessCheckName}/resource/{ResourceIdentifier}/status", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Gets the readiness status for an individual readiness check. To see the overall readiness status for a recovery group, that considers the readiness status for all the readiness checks in a recovery group, use GetRecoveryGroupReadinessSummary.
    public func getReadinessCheckStatus(_ input: GetReadinessCheckStatusRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetReadinessCheckStatusResponse {
        return try await self.client.execute(operation: "GetReadinessCheckStatus", path: "/readinesschecks/{ReadinessCheckName}/status", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Gets details about a recovery group, including a list of the cells that are included in it.
    public func getRecoveryGroup(_ input: GetRecoveryGroupRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetRecoveryGroupResponse {
        return try await self.client.execute(operation: "GetRecoveryGroup", path: "/recoverygroups/{RecoveryGroupName}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Displays a summary of information about a recovery group's readiness status. Includes the readiness checks for resources in the recovery group and the readiness status of each one.
    public func getRecoveryGroupReadinessSummary(_ input: GetRecoveryGroupReadinessSummaryRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetRecoveryGroupReadinessSummaryResponse {
        return try await self.client.execute(operation: "GetRecoveryGroupReadinessSummary", path: "/recoverygroupreadiness/{RecoveryGroupName}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Displays the details about a resource set, including a list of the resources in the set.
    public func getResourceSet(_ input: GetResourceSetRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> GetResourceSetResponse {
        return try await self.client.execute(operation: "GetResourceSet", path: "/resourcesets/{ResourceSetName}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the cells for an account.
    public func listCells(_ input: ListCellsRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListCellsResponse {
        return try await self.client.execute(operation: "ListCells", path: "/cells", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the cross-account readiness authorizations that are in place for an account.
    public func listCrossAccountAuthorizations(_ input: ListCrossAccountAuthorizationsRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListCrossAccountAuthorizationsResponse {
        return try await self.client.execute(operation: "ListCrossAccountAuthorizations", path: "/crossaccountauthorizations", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the readiness checks for an account.
    public func listReadinessChecks(_ input: ListReadinessChecksRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListReadinessChecksResponse {
        return try await self.client.execute(operation: "ListReadinessChecks", path: "/readinesschecks", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the recovery groups in an account.
    public func listRecoveryGroups(_ input: ListRecoveryGroupsRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListRecoveryGroupsResponse {
        return try await self.client.execute(operation: "ListRecoveryGroups", path: "/recoverygroups", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the resource sets in an account.
    public func listResourceSets(_ input: ListResourceSetsRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListResourceSetsResponse {
        return try await self.client.execute(operation: "ListResourceSets", path: "/resourcesets", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists all readiness rules, or lists the readiness rules for a specific resource type.
    public func listRules(_ input: ListRulesRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListRulesResponse {
        return try await self.client.execute(operation: "ListRules", path: "/rules", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Lists the tags for a resource.
    public func listTagsForResources(_ input: ListTagsForResourcesRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> ListTagsForResourcesResponse {
        return try await self.client.execute(operation: "ListTagsForResources", path: "/tags/{ResourceArn}", httpMethod: .GET, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Adds a tag to a resource.
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> TagResourceResponse {
        return try await self.client.execute(operation: "TagResource", path: "/tags/{ResourceArn}", httpMethod: .POST, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Removes a tag from a resource.
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws {
        return try await self.client.execute(operation: "UntagResource", path: "/tags/{ResourceArn}", httpMethod: .DELETE, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a cell to replace the list of nested cells with a new list of nested cells.
    public func updateCell(_ input: UpdateCellRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateCellResponse {
        return try await self.client.execute(operation: "UpdateCell", path: "/cells/{CellName}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a readiness check.
    public func updateReadinessCheck(_ input: UpdateReadinessCheckRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateReadinessCheckResponse {
        return try await self.client.execute(operation: "UpdateReadinessCheck", path: "/readinesschecks/{ReadinessCheckName}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a recovery group.
    public func updateRecoveryGroup(_ input: UpdateRecoveryGroupRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateRecoveryGroupResponse {
        return try await self.client.execute(operation: "UpdateRecoveryGroup", path: "/recoverygroups/{RecoveryGroupName}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }

    /// Updates a resource set.
    public func updateResourceSet(_ input: UpdateResourceSetRequest, logger: Logger = AWSClient.loggingDisabled, on eventLoop: EventLoop? = nil) async throws -> UpdateResourceSetResponse {
        return try await self.client.execute(operation: "UpdateResourceSet", path: "/resourcesets/{ResourceSetName}", httpMethod: .PUT, serviceConfig: self.config, input: input, logger: logger, on: eventLoop)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Route53RecoveryReadiness {
    ///  Gets readiness for a cell. Aggregates the readiness of all the resources that are associated with the cell into a single value.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func getCellReadinessSummaryPaginator(
        _ input: GetCellReadinessSummaryRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<GetCellReadinessSummaryRequest, GetCellReadinessSummaryResponse> {
        return .init(
            input: input,
            command: self.getCellReadinessSummary,
            inputKey: \GetCellReadinessSummaryRequest.nextToken,
            outputKey: \GetCellReadinessSummaryResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }

    ///  Gets individual readiness status for a readiness check. To see the overall readiness status for a recovery group, that considers the readiness status for all the readiness checks in the recovery group, use GetRecoveryGroupReadinessSummary.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func getReadinessCheckResourceStatusPaginator(
        _ input: GetReadinessCheckResourceStatusRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<GetReadinessCheckResourceStatusRequest, GetReadinessCheckResourceStatusResponse> {
        return .init(
            input: input,
            command: self.getReadinessCheckResourceStatus,
            inputKey: \GetReadinessCheckResourceStatusRequest.nextToken,
            outputKey: \GetReadinessCheckResourceStatusResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }

    ///  Gets the readiness status for an individual readiness check. To see the overall readiness status for a recovery group, that considers the readiness status for all the readiness checks in a recovery group, use GetRecoveryGroupReadinessSummary.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func getReadinessCheckStatusPaginator(
        _ input: GetReadinessCheckStatusRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<GetReadinessCheckStatusRequest, GetReadinessCheckStatusResponse> {
        return .init(
            input: input,
            command: self.getReadinessCheckStatus,
            inputKey: \GetReadinessCheckStatusRequest.nextToken,
            outputKey: \GetReadinessCheckStatusResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }

    ///  Displays a summary of information about a recovery group's readiness status. Includes the readiness checks for resources in the recovery group and the readiness status of each one.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func getRecoveryGroupReadinessSummaryPaginator(
        _ input: GetRecoveryGroupReadinessSummaryRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<GetRecoveryGroupReadinessSummaryRequest, GetRecoveryGroupReadinessSummaryResponse> {
        return .init(
            input: input,
            command: self.getRecoveryGroupReadinessSummary,
            inputKey: \GetRecoveryGroupReadinessSummaryRequest.nextToken,
            outputKey: \GetRecoveryGroupReadinessSummaryResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }

    ///  Lists the cells for an account.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func listCellsPaginator(
        _ input: ListCellsRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<ListCellsRequest, ListCellsResponse> {
        return .init(
            input: input,
            command: self.listCells,
            inputKey: \ListCellsRequest.nextToken,
            outputKey: \ListCellsResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }

    ///  Lists the cross-account readiness authorizations that are in place for an account.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func listCrossAccountAuthorizationsPaginator(
        _ input: ListCrossAccountAuthorizationsRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<ListCrossAccountAuthorizationsRequest, ListCrossAccountAuthorizationsResponse> {
        return .init(
            input: input,
            command: self.listCrossAccountAuthorizations,
            inputKey: \ListCrossAccountAuthorizationsRequest.nextToken,
            outputKey: \ListCrossAccountAuthorizationsResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }

    ///  Lists the readiness checks for an account.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func listReadinessChecksPaginator(
        _ input: ListReadinessChecksRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<ListReadinessChecksRequest, ListReadinessChecksResponse> {
        return .init(
            input: input,
            command: self.listReadinessChecks,
            inputKey: \ListReadinessChecksRequest.nextToken,
            outputKey: \ListReadinessChecksResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }

    ///  Lists the recovery groups in an account.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func listRecoveryGroupsPaginator(
        _ input: ListRecoveryGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<ListRecoveryGroupsRequest, ListRecoveryGroupsResponse> {
        return .init(
            input: input,
            command: self.listRecoveryGroups,
            inputKey: \ListRecoveryGroupsRequest.nextToken,
            outputKey: \ListRecoveryGroupsResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }

    ///  Lists the resource sets in an account.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func listResourceSetsPaginator(
        _ input: ListResourceSetsRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<ListResourceSetsRequest, ListResourceSetsResponse> {
        return .init(
            input: input,
            command: self.listResourceSets,
            inputKey: \ListResourceSetsRequest.nextToken,
            outputKey: \ListResourceSetsResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }

    ///  Lists all readiness rules, or lists the readiness rules for a specific resource type.
    /// Return PaginatorSequence for operation.
    ///
    /// - Parameters:
    ///   - input: Input for request
    ///   - logger: Logger used flot logging
    ///   - eventLoop: EventLoop to run this process on
    public func listRulesPaginator(
        _ input: ListRulesRequest,
        logger: Logger = AWSClient.loggingDisabled,
        on eventLoop: EventLoop? = nil
    ) -> AWSClient.PaginatorSequence<ListRulesRequest, ListRulesResponse> {
        return .init(
            input: input,
            command: self.listRules,
            inputKey: \ListRulesRequest.nextToken,
            outputKey: \ListRulesResponse.nextToken,
            logger: logger,
            on: eventLoop
        )
    }
}

#endif // compiler(>=5.5.2) && canImport(_Concurrency)
